package com.fengniaoxls.fengniaonewretail;

import android.annotation.SuppressLint;
import android.content.Context;
import android.content.Intent;
import android.graphics.PixelFormat;
import android.os.Build;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.WindowManager;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.VideoView;

import com.freak.httphelper.log.LogUtil;

import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 音视频通话悬浮窗操作类
 */
public class FloatWindow {
    /**
     * 定时任务
     */
    private ScheduledThreadPoolExecutor scheduled;

    // 上下文菜单
    private Context context;

    // 当前单例类实例
    private static FloatWindow instance;

    private WindowManager windowManager = null;
    private WindowManager.LayoutParams layoutParams = null;

    // 悬浮窗需要显示的布局
    private View floatView;
    private TextView callTimeView;
    private boolean isStartScheduled = false;

    public FloatWindow(Context context) {
        this.context = context;
        windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    }

    public static FloatWindow getInstance(Context context) {
        if (instance == null) {
            instance = new FloatWindow(context);
        }
        return instance;
    }

    /**
     * 开始展示悬浮窗
     */
    public void addFloatWindow() {
        if (floatView != null) {
            return;
        }
//        EventBus.getDefault()
//                .register(this);
        layoutParams = new WindowManager.LayoutParams();
        // 位置为右侧顶部
        layoutParams.gravity = Gravity.LEFT | Gravity.TOP;
        // 设置宽高自适应
        layoutParams.width = WindowManager.LayoutParams.WRAP_CONTENT;
        layoutParams.height = WindowManager.LayoutParams.WRAP_CONTENT;

        // 设置悬浮窗透明
        layoutParams.format = PixelFormat.TRANSPARENT;

        // 设置窗口类型
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            layoutParams.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
        } else {
            layoutParams.type = WindowManager.LayoutParams.TYPE_SYSTEM_ALERT;
        }

        // 设置窗口标志类型，其中 FLAG_NOT_FOCUSABLE 是放置当前悬浮窗拦截点击事件，造成桌面控件不可操作
        layoutParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE | WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM;

        // 获取要现实的布局
        floatView = LayoutInflater.from(context)
                .inflate(R.layout.widget_float_window, null);
        // 添加悬浮窗 View 到窗口
        windowManager.addView(floatView, layoutParams);


        floatView.findViewById(R.id.layout_call_voice)
                .setVisibility(View.VISIBLE);
        callTimeView = (TextView) floatView.findViewById(R.id.text_call_time);


        // 当点击悬浮窗时，返回到通话界面
        floatView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                LogUtil.e("点击悬浮窗");
                Intent intent = new Intent();
                intent.setClass(context, MainNewActivity.class);
                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                context.startActivity(intent);
            }
        });
        //设置监听浮动窗口的触摸移动
        floatView.setOnTouchListener(new View.OnTouchListener() {
            boolean result = false;

            float x = 0;
            float y = 0;
            float startX = 0;
            float startY = 0;

            @Override
            public boolean onTouch(View v, MotionEvent event) {
                LogUtil.e("触摸移动悬浮窗");
                switch (event.getAction()) {
                    case MotionEvent.ACTION_DOWN:
                        result = false;
                        x = event.getX();
                        y = event.getY();
                        startX = event.getRawX();
                        startY = event.getRawY();
                        LogUtil.e("start x: %f, y: %f" + startX + startY);
                        break;
                    case MotionEvent.ACTION_MOVE:
                        LogUtil.e("move x: %f, y: %f" + event.getRawX() + event.getRawY());
                        // 当移动距离大于特定值时，表示是拖动悬浮窗，则不触发后边的点击监听
                        if (Math.abs(event.getRawX() - startX) > 20 || Math.abs(event.getRawY() - startY) > 20) {
                            result = true;
                        }
                        // getRawX 获取触摸点相对于屏幕的坐标，getX 相对于当前悬浮窗坐标
                        // 根据当前触摸点 X 坐标计算悬浮窗 X 坐标，
                        layoutParams.x = (int) (event.getRawX() - x);
                        // 根据当前触摸点 Y 坐标计算悬浮窗 Y 坐标，减25为状态栏的高度
                        layoutParams.y = (int) (event.getRawY() - y - 25);
                        // 刷新悬浮窗
                        windowManager.updateViewLayout(floatView, layoutParams);
                        break;
                    case MotionEvent.ACTION_UP:
                        break;
                    default:
                        break;
                }
                return result;
            }
        });
        if (scheduled == null) {
            Log.e("TAG", "锁屏定时任务");
            scheduled = new ScheduledThreadPoolExecutor(2);
        }
        timingTask();
    }


    /**
     * 停止悬浮窗
     */
    public void removeFloatWindow() {
        if (windowManager != null && floatView != null) {
            windowManager.removeView(floatView);
            floatView = null;
        }
        scheduled.shutdown();
        scheduled=null;
        handler.removeMessages(0);
    }

    public void timingTask() {
//        if ((boolean) SPUtils.get(App.getInstance().getApplicationContext(),
//                (String) SPUtils.get(App.getInstance().getApplicationContext(), Constants.USER_CODE, "")
//                        + Constants.VOICE_OPEN_STATUS, false)) {
        //延时1s，每隔300000(5分钟)毫秒执行一次run方法
        if (scheduled != null) {
            /**
             * 0表示首次执行任务的延迟时间，5表示每次执行任务的间隔时间，TimeUnit.MINUTES执行的时间间隔数值单位
             * 间隔单位毫秒：TimeUnit.MILLISECONDS
             * 间隔单位秒：TimeUnit.SECONDS
             * 间隔单位分钟：TimeUnit.MINUTES
             * 间隔单位小时：TimeUnit.HOURS
             * 间隔单位天：TimeUnit.DAYS
             * scheduleAtFixedRate和scheduleWithFixedDelay的区别：
             * scheduleAtFixedRate：是上一个任务开始执行之后延迟设定时间再执行，是从上一个任务开始时计时，
             *                      但对于运行时长超过延迟时长的任务，会等上一个任务执行完之后，下一个任务才开始执行，
             *                      此时，延时没有任何意义。
             * scheduleWithFixedDelay：scheduleWithFixedDelay是在上一个任务结束执行之后延迟设定时间再执行，
             *                          是从上一个任务结束时开始计算。
             */
            scheduled.scheduleWithFixedDelay(new Runnable() {
                @Override
                public void run() {
                    Message message = new Message();
                    message.what = 1;
                    handler.sendMessage(message);
                }
            }, 0, 2, TimeUnit.SECONDS);

        }
//        }
    }

    @SuppressLint("HandlerLeak")
    Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            if (msg.what == 1) {
//                getJPushStatus();
                Log.e("TAG", "获取状态");
            }
            super.handleMessage(msg);
        }
    };
}
